home *** CD-ROM | disk | FTP | other *** search
/ Software Vault: The Games Collection 1 / software vault.zip / software vault / CDR10 / YICN23.ZIP / UNITS / YAKLIB.CPP < prev    next >
C/C++ Source or Header  |  1993-02-21  |  9KB  |  311 lines
  1. #include "stddefs.h"
  2. #include "yaklib.h"
  3. #include <string.h>
  4. #include <stdio.h>
  5. #include <ctype.h>
  6.  
  7. int tolower(char * theString)
  8. {
  9.   for(int counter = 0; counter < strlen(theString); ++counter)
  10.     theString[counter] = tolower(theString[counter]);
  11.   return(0);
  12. }
  13.  
  14. void yakLib::open(char * filename)
  15. {
  16.   int temp;
  17.   char fullFilename[15];
  18.   strcpy(fullFilename, filename);
  19.   if(strncmp(fullFilename + strlen(fullFilename) - 4, ".yar", 4))
  20.      strcat(fullFilename, ".yar");
  21.   strcpy(libFilename, fullFilename);
  22.   myDataFile.open(fullFilename, ios::binary | ios::in | ios::out);
  23.   myDataFile.seekg(0, ios::end);
  24.   if (myDataFile.tellg() == 0)
  25.     numberOfEntries = 0;
  26.   else
  27.   {
  28.     myDataFile.seekg(-(int)sizeof(numberOfEntries), ios::end);
  29.     temp = myDataFile.tellg();
  30.     if(temp == 0);
  31.     byte tempByte = myDataFile.peek();
  32.     if(tempByte);
  33.     myDataFile.read((byte *) &numberOfEntries, (int)sizeof(numberOfEntries));
  34.   }
  35.   getDirectoryIndex();
  36. }
  37.  
  38. yakLib::yakLib(char * filename)
  39. {
  40.   open(filename);
  41. }
  42.  
  43. void yakLib::getDirectoryIndex(void)
  44. {
  45.   long temp = myDataFile.tellg();
  46.   myDataFile.seekg(0);
  47.   long temp2 = myDataFile.tellg();
  48.   if (temp2);
  49.  
  50.   myDataFile.seekg(0, ios::end);
  51.   temp2 = myDataFile.tellg();
  52.   if (temp2);
  53.   if (myDataFile.tellg() == 0)
  54.   {
  55.     directoryIndex = 0;
  56.     return;
  57.   }
  58.   myDataFile.seekg(-((int)sizeof(numberOfEntries) + numberOfEntries*(int)sizeof(directoryEntry)), ios::end);
  59.   directoryIndex = myDataFile.tellg();
  60.   myDataFile.seekg(temp);
  61. }
  62.  
  63. directoryEntry yakLib::getIndex(char * filename)
  64. {
  65.   directoryEntry myDirectoryEntry;
  66.   myDataFile.seekg(directoryIndex);
  67.   tolower(filename);
  68.   for (int counter = 0; counter < numberOfEntries; ++counter)
  69.   {
  70.     myDataFile.read((char *)&myDirectoryEntry, (int)sizeof(directoryEntry));
  71.     if (strcmp(myDirectoryEntry.filename, filename) == 0)
  72.       return(myDirectoryEntry);
  73.   }
  74.   strcpy(myDirectoryEntry.filename, "");
  75.   myDirectoryEntry.size = 0;
  76.   myDirectoryEntry.index = 0;
  77.   return myDirectoryEntry;
  78. }
  79.  
  80. unsigned long yakLib::fileSize(char * filename)
  81. {
  82.   return getIndex(filename).size;
  83. }
  84.  
  85. void yakLib::listFiles(void)
  86. {
  87.   directoryEntry myDirectoryEntry;
  88.   myDataFile.seekg(directoryIndex);
  89.   cout << "\n\n";
  90.   for (int counter = 0; counter < numberOfEntries; ++counter)
  91.   {
  92.     myDataFile.read((char *)&myDirectoryEntry, (int)sizeof(directoryEntry));
  93.     cout << myDirectoryEntry.filename << "\t" << myDirectoryEntry.size << "\t";
  94.     cout << myDirectoryEntry.index << "\n";
  95.   }
  96. }
  97.  
  98. void yakLib::addFile(char * filename)
  99. {
  100.   fstream myInputFile(filename, ios::in | ios::binary);
  101.   char tempName[15];
  102.   tmpnam(tempName);
  103.   fstream myTempFile(tempName, ios::out | ios::binary);
  104.   directoryEntry newDirectoryEntry;
  105.   byte * myBuffer = new byte[33000];
  106.   long miscNumber = 0, counter = 0;
  107.   tolower(filename);
  108.   if (myInputFile)
  109.   {
  110.     newDirectoryEntry = getIndex(filename);
  111.     if (newDirectoryEntry.size != 0)
  112.       deleteFile(filename);
  113.     myDataFile.seekg(0);
  114.     if (myBuffer == NULL)
  115.     {
  116.       while(myTempFile.tellg() < directoryIndex)
  117.     myTempFile.put(myDataFile.get());          //copy datafile to temp
  118.     }
  119.     else
  120.     {
  121.       for (long bytesLeft = directoryIndex; bytesLeft > 0;)
  122.       {
  123.     miscNumber = (bytesLeft < 32000) ? bytesLeft : 32000;
  124.     myDataFile.read(myBuffer, (int)miscNumber);
  125.     myTempFile.write(myBuffer, (int)miscNumber);
  126.     bytesLeft -= miscNumber;
  127.       }
  128.     }
  129.     myInputFile.seekg(0, ios::end);         //go to end of infile
  130.     newDirectoryEntry.size = myInputFile.tellg(); //find out how big our file is
  131.     newDirectoryEntry.index = myTempFile.tellp(); //and where it'll be
  132.     strncpy(newDirectoryEntry.filename, filename, 15); //and its filename
  133.     myInputFile.seekg(0);
  134.     if (myBuffer == NULL)
  135.     {
  136.       for(counter = 0; counter < newDirectoryEntry.size; ++counter)
  137.     myTempFile.put(myInputFile.get());          //copy datafile to temp
  138.     }
  139.     else
  140.     {
  141.       for (long bytesLeft = newDirectoryEntry.size; bytesLeft > 0;)
  142.       {
  143.     miscNumber = (bytesLeft < 32000) ? bytesLeft : 32000;
  144.     myInputFile.read(myBuffer, (int)miscNumber);
  145.     myTempFile.write(myBuffer, (int)miscNumber);
  146.     bytesLeft -= miscNumber;
  147.       }
  148.     }
  149.     for (counter = 0; counter <  numberOfEntries*(int)sizeof(directoryEntry); ++counter)
  150.       myTempFile.put(myDataFile.get());          //copy datafile to temp
  151.  
  152.     myTempFile.write((byte *) &newDirectoryEntry, (int)sizeof(directoryEntry));
  153.     ++numberOfEntries;
  154.     int temp = myTempFile.tellp();
  155.     if (temp);
  156.     myTempFile.write((byte *) &numberOfEntries, (int)sizeof(numberOfEntries));
  157.     myTempFile.close();
  158.     myDataFile.close();
  159.     remove(libFilename);
  160.     rename(tempName, libFilename);
  161.     open(libFilename);
  162.   }
  163.   delete(myBuffer);
  164. }
  165.  
  166. void yakLib::extractFile(char * filename)
  167. {
  168.   fstream myOutputFile;
  169.   byte * myBuffer = new byte[33000];
  170.   long miscNumber;
  171.   tolower(filename);
  172.   directoryEntry myDirectoryEntry = getIndex(filename);
  173.   if (myDirectoryEntry.size != 0)
  174.   {
  175.     myOutputFile.open(filename, ios::out | ios::binary);
  176.     myDataFile.seekg(myDirectoryEntry.index);
  177.     if (myBuffer == NULL)
  178.     {
  179.       for (long counter = 0; counter < myDirectoryEntry.size; ++counter)
  180.     myOutputFile.put(myDataFile.get());
  181.     }
  182.     else
  183.     {
  184.       for (long bytesLeft = myDirectoryEntry.size; bytesLeft > 0;)
  185.       {
  186.     miscNumber = (bytesLeft < 32000) ? bytesLeft : 32000;
  187.     myDataFile.read(myBuffer, (int)miscNumber);
  188.     myOutputFile.write(myBuffer, (int)miscNumber);
  189.     bytesLeft -= miscNumber;
  190.       }
  191.     }
  192.   }
  193.   delete myBuffer;
  194. }
  195.  
  196. int yakLib::deleteFile(char * filename)
  197. {
  198.   tolower(filename);
  199.   char tempName[15];
  200.   tmpnam(tempName);
  201.   fstream myTempFile(tempName, ios::out | ios::binary);
  202.   char * myBuffer = new char[33000];
  203.   long miscNumber;
  204.   directoryEntry newDirectoryEntry = getIndex(filename), tempDirectoryEntry;
  205.   myDataFile.seekg(0);
  206.   if (newDirectoryEntry.size == 0)
  207.   {
  208.     delete myBuffer;
  209.     return(1);
  210.   }
  211.   if (myBuffer == NULL)
  212.   {
  213.     for (int counter = 0; counter < newDirectoryEntry.index; ++counter)
  214.       myTempFile.put(myDataFile.get());  //copy everything up to the deleted file
  215.   }
  216.   else
  217.   {
  218.     for (long bytesLeft = newDirectoryEntry.index; bytesLeft > 0;)
  219.     {
  220.       miscNumber = (bytesLeft < 32000) ? bytesLeft : 32000;
  221.       myDataFile.read(myBuffer, (int)miscNumber);
  222.       myTempFile.write(myBuffer, (int)miscNumber);
  223.       bytesLeft -= miscNumber;
  224.     }
  225.   }
  226.   myDataFile.seekg(newDirectoryEntry.size, ios::cur);
  227.   if (myBuffer == NULL)
  228.   {
  229.     while(myDataFile.tellg() < directoryIndex)
  230.     myTempFile.put(myDataFile.get());    //copy everything after the deleted file
  231.   }
  232.   else
  233.   {
  234.     for (long bytesLeft = directoryIndex - myDataFile.tellg(); bytesLeft > 0;)
  235.     {
  236.       miscNumber = (bytesLeft < 32000) ? bytesLeft : 32000;
  237.       myDataFile.read(myBuffer, (int)miscNumber);
  238.       myTempFile.write(myBuffer, (int)miscNumber);
  239.       bytesLeft -= miscNumber;
  240.     }
  241.   }
  242.   for (int counter = 0; counter < numberOfEntries; ++counter)
  243.   {
  244.     myDataFile.read((byte *) &tempDirectoryEntry, sizeof(directoryEntry));
  245.     if (tempDirectoryEntry.index != newDirectoryEntry.index)
  246.     {
  247.       if (tempDirectoryEntry.index > newDirectoryEntry.index)
  248.     tempDirectoryEntry.index -= newDirectoryEntry.size;
  249.       myTempFile.write((byte *) &tempDirectoryEntry, sizeof(directoryEntry));
  250.     }
  251.   }
  252.   --numberOfEntries;
  253.   myTempFile.write((byte *) &numberOfEntries, sizeof(numberOfEntries));
  254.   myTempFile.close();
  255.   myDataFile.close();
  256.   remove(libFilename);
  257.   rename(tempName, libFilename);
  258.   open(libFilename);
  259.   delete myBuffer;
  260.   return(0);
  261. }
  262.  
  263. byte * yakLib::loadToMem(char * filename)
  264. {
  265.   byte * loadBuffer = NULL;
  266.   long loadBufferIndex = 0;
  267.   long miscNumber;
  268.   tolower(filename);
  269.   directoryEntry myDirectoryEntry = getIndex(filename);
  270.   if (myDirectoryEntry.size != 0)
  271.   {
  272.     loadBuffer = new char[myDirectoryEntry.size + 1];
  273.     myDataFile.seekg(myDirectoryEntry.index);
  274.     if (loadBuffer)
  275.     {
  276.       for (long bytesLeft = myDirectoryEntry.size; bytesLeft > 0;)
  277.       {
  278.     miscNumber = (bytesLeft < 32000) ? bytesLeft : 32000;
  279.     myDataFile.read(loadBuffer + loadBufferIndex, (int)miscNumber);
  280.     bytesLeft -= miscNumber;
  281.     loadBufferIndex += miscNumber;
  282.       }
  283.     }
  284.   }
  285.   *(loadBuffer + loadBufferIndex) = 0;
  286.   return(loadBuffer);
  287. }
  288.  
  289. byte * loadDosToMem(char * filename)
  290. {
  291.   byte * loadBuffer = NULL;
  292.   long loadBufferIndex = 0;
  293.   long miscNumber;
  294.   ifstream myInStream(filename, ios::binary);
  295.   if (!myInStream)
  296.     return NULL;
  297.   myInStream.seekg(0, ios::end);
  298.   long size = myInStream.tellg();
  299.   loadBuffer = new char[size];
  300.   myInStream.seekg(0, ios::beg);
  301.   if (!loadBuffer)
  302.     return NULL;
  303.   for (long bytesLeft = size; bytesLeft > 0;)
  304.   {
  305.     miscNumber = (bytesLeft < 32000) ? bytesLeft : 32000;
  306.     myInStream.read(loadBuffer + loadBufferIndex, (int)miscNumber);
  307.     bytesLeft -= miscNumber;
  308.     loadBufferIndex += miscNumber;
  309.   }
  310.   return loadBuffer;
  311. }